home *** CD-ROM | disk | FTP | other *** search
/ Developer CD Series 1998 August: Tool Chest / Dev.CD Aug 98 TC.toast / Sample Code / QuickDraw / TubeTest / TubeTest.c < prev    next >
Encoding:
C/C++ Source or Header  |  1994-11-18  |  14.1 KB  |  465 lines  |  [TEXT/MPS ]
  1. /*------------------------------------------------------------------------------
  2. #
  3. #    Macintosh Developer Technical Support
  4. #
  5. #    Simple Color QuickDraw Animation Sample Application
  6. #
  7. #    TubeTest
  8. #
  9. #    TubeTest.c    -    C Source
  10. #
  11. #    Copyright © 1988 Apple Computer, Inc.
  12. #    All rights reserved.
  13. #
  14. #    Versions:    1.00                8/88
  15. #                1.01                6/92
  16. #
  17. #    Components:    TubeTest.p            August 1, 1988
  18. #                TubeTest.c            August 1, 1988
  19. #                TubeTest.r            August 1, 1988
  20. #                PTubeTest.make        August 1, 1988
  21. #                CTubeTest.make        August 1, 1988
  22. #                TCTubeTest.π        June 4, 1992
  23. #                TCTubeTest.π.rsrc    June 4, 1992
  24. #
  25. #    The TubeTest program is a simple demonstration of how to use the Palette 
  26. #    Manager in a color program.  It has a special color palette that is associated
  27. #    with the main window.  The colors are animated using the Palette Manager 
  28. #    to give a flowing tube effect.  The program is very simple, and the Palette
  29. #    Manager and drawing parts are put in separate subroutines to make it easier
  30. #    to figure out what is happening.
  31. #    
  32. #    The program is still a complete Macintosh application with a Main Event Loop,
  33. #    so there is the extra code to run the MEL.  
  34. #    
  35. #    There is a resource file that is necessary as well, to define the Menus, Window,
  36. #    Dialog, and Palette resources used in the program.  
  37. #
  38. #    See Sample and TESample for the general structure and MultiFinder techniques that
  39. #    we recommend that you use when building a new application.
  40. #
  41. ------------------------------------------------------------------------------*/
  42.  
  43.  /*
  44.     File TubeTest.c
  45.  
  46.     Version 1.0:  6/2/88
  47.                  7/20/88    DJB    Converted to C (MPW 3.0 ONLY)
  48.     
  49.     4/19/88:
  50.     TubeTest -- A small sample application written by Bo3b Johnson.
  51.     The idea is to draw two circles in varying colors in the window, then
  52.     animate the colors when the menu is chosen.    This is a complete program
  53.     with event loop and everything.    It is intended to be a simple example of
  54.     how to use the Palette Manager to do some minor color animation, and
  55.     how to use the PM to set up the colors desired in a window.
  56.     
  57.     Also see the resource file that goes with this to see how the Palette 
  58.     itself is layed out.
  59.     
  60.     Could be built with something like this:
  61.         rez TubeTest.r -o TubeTest
  62.         C -r TubeTest.C
  63.         Link TubeTest.c.o ∂
  64.             "{Libraries}"Interface.o ∂
  65.             "{CLibraries}"CRuntime.o ∂
  66.             -o CTubeTest
  67.         CTubeTest
  68.  */
  69.  
  70. /* Where does it fit:
  71.     This is a series of sample programs for those doing development
  72.     using Color QuickDraw.  Since the whole color problem depends
  73.     upon the exact effect desired, there are a number of answers
  74.     to how to use colors, from the simple to the radically complex.
  75.     These programs try to cover the gamut, so you should use 
  76.     which ever seems appropriate.  In most cases, use the simplest
  77.     one that will give the desired results.  The compatibility
  78.     rating is from 0..9 where low is better.  The more known risks 
  79.     there are the higher the rating.
  80.     
  81.     
  82.     The programs (in order of compatibility):
  83.     
  84.         SillyBalls:
  85.             This is the simplest use of Color QuickDraw, and does
  86.             not use the Palette Manager.  It draws randomly colored
  87.             balls in a color window.  This is intended to give you
  88.             the absolute minimum required to get color on the screen.
  89.             Written in straight Pascal code.
  90.             Compatibility rating = 0, no known risks.
  91.         
  92.         FracAppPalette:
  93.             This is a version of FracApp that uses only the Palette
  94.             Manager.  It does not support color table animation
  95.             since that part of the Palette Manager is not sufficient.
  96.             The program demonstrates a full color palette that is
  97.             used to display the Mandelbrot set.  It uses an offscreen
  98.             gDevice w/ Port to handle the data, using CopyBits to
  99.             draw to the window.  The Palette is automatically 
  100.             associated with each window.  The PICT files are read
  101.             and written using the bottlenecks, to save on memory
  102.             useage.
  103.             Written in MacApp Object Pascal code.
  104.             Compatibility rating = 0, no known risks.
  105.         
  106.         TubeTest:    (***)
  107.             This is a small demo program that demonstrates using the
  108.             Palette Manager for color table animation.  It uses a 
  109.             color palette with animating entries, and draws using the
  110.             Palette Manager.  There are two circles of animating colors
  111.             which gives a flowing tube effect.  This is a valid case
  112.             for using the animating colors aspect of the Palette Manager,
  113.             since the image is being drawn directly.
  114.             Written in straight Pascal code.
  115.             Compatibility rating = 0, no known risks.
  116.         
  117.         FracApp:
  118.             This is the ‘commercial quality’ version of FracApp.  This
  119.             version supports color table animation, using an offscreen
  120.             gDevice w/ Port, and handles multiple documents.  The
  121.             CopyBits updates to the screen are as fast as possible.  The
  122.             program does not use the Palette Manager, except to
  123.             provide for the system palette, or color modes with less than
  124.             255 colors.  For color table animation using an offscreen
  125.             gDevice w/ Port, it uses the Color Manager and handles the
  126.             colors itself.  Strict compatibility was relaxed to allow for
  127.             a higher performance program.  This is the most ‘real’ of the
  128.             sample programs.
  129.             Written in MacApp Object Pascal code.
  130.             Compatibility rating = 2.  (nothing will break, but it may not
  131.                 always look correct.)
  132.         
  133.         FracApp300:
  134.             This doesn't support colors, but demonstrates how to create and
  135.             use a 300 dpi bitmap w/ Port.  The bitmap is printed at full
  136.             resolution on LaserWriters, and clipped on other printers (but
  137.             they still print).  It demonstrates how to use a high resolution
  138.             image as a PICT file, and how to print them out.
  139.             Written in MacApp Object Pascal code.
  140.             Compatibility rating = 1.  (The use of PrGeneral is slightly 
  141.                 out of the ordinary, although supported.)
  142. */
  143.  
  144.  
  145. #include <Types.h>
  146. #include <Memory.h>
  147. #include <Quickdraw.h>
  148. #include <Palettes.h>
  149. #include <Fonts.h>
  150. #include <Events.h>
  151. #include <Menus.h>
  152. #include <Windows.h>
  153. #include <TextEdit.h>
  154. #include <Dialogs.h>
  155. #include <Menus.h>
  156. #include <Devices.h>
  157. #include <Events.h>
  158. #include <OSUtils.h>
  159. #include <ToolUtils.h>
  160. #include <SegLoad.h>
  161.     
  162. /* Constants */
  163. #define appleID                1000            /* resource IDs/menu IDs for Apple, */
  164. #define fileID                1001            /*     File and */
  165. #define editID                1002            /*    Edit menus */
  166.     
  167. #define appleM                0                /* Index for each menu in myMenus (array of menu handles) */
  168. #define fileM                1
  169. #define editM                2
  170.  
  171. #define menuCount            3                /* Total number of menus */
  172.  
  173. #define windowID            1000            /* Resource ID for main window */
  174. #define aboutMeDLOG         1000            /* And Resource ID for About box dialog. */
  175.  
  176. #define tubularItem            1                /* When checked, animation of colors. */
  177. #define quitItem            3                /* Quit in the menu of course. */
  178.  
  179. #define aboutMeCommand        1                /* Menu item in apple menu for About TubeTest item */
  180.     
  181. #define totalColors            152                /* use 150 colors in our palette for drawing eyes. */
  182. #define numColors            150                /* to skip black and white. */
  183.     
  184.     
  185. /* Globals */
  186. MenuHandle    myMenus[menuCount];
  187. Rect        dragRect;                        /* Rectangle used to mark bounds for dragging window */
  188. Boolean        doneFlag,                        /* true if user has chosen Quit command */
  189.             tubeCheck;                        /* if true, the menu is checked, and we animate. */
  190. EventRecord    myEvent;
  191. WindowPtr    myWindow,
  192.             whichWindow;
  193. char        theChar;
  194. OSErr        error;
  195. SysEnvRec    theWorld;
  196.  
  197. /* Prototypes */
  198. void DrawEyes();
  199. void SetUpMenus();
  200. void ShiftyColors();
  201. void ShowAboutMeDialog();
  202. void DoCommand(long int mResult);
  203.  
  204.  
  205. /* Make the 2.0 Interface for passing Points to the Toolbox by address,
  206.    emulate the 3.0 method of passing Points by value. This list only contains
  207.    the affected routines actually used in this sample, and is not intended to
  208.    be a comprehensive list of the affected routines. */
  209. #ifdef MPW2
  210. #    define FindWindow    FINDWINDOW
  211. #    define MenuSelect    MENUSELECT
  212. #endif
  213.  
  214.     
  215. main()
  216. {
  217.     /*
  218.     **    Test the computer to be sure we can do color.  
  219.     **    If not we would crash, which would be bad.  
  220.     **    If we can’t run, just beep and exit.
  221.     */
  222.     error = SysEnvirons(1, &theWorld);
  223.     if (theWorld.hasColorQD == false) {
  224.         SysBeep (50);
  225.         ExitToShell();                            /* If no color QD, we must leave. */
  226.     };
  227.  
  228.     InitGraf(&qd.thePort);
  229.     InitFonts();
  230.     InitWindows();
  231.     InitMenus();
  232.     TEInit();
  233.     InitDialogs(nil);
  234.     InitCursor();
  235.  
  236.     SetRect(&dragRect, 4, 24, qd.screenBits.bounds.right - 4, qd.screenBits.bounds.bottom - 4);
  237.     doneFlag = false;                            /* flag to detect when Quit command is chosen */
  238.     tubeCheck = false;                            /* flag for animating color is initially off. */
  239.  
  240.     /*
  241.     **    Open the color window.
  242.     */
  243.     myWindow = GetNewCWindow(windowID, nil, (WindowPtr) -1);
  244.     SetPort(myWindow);
  245.  
  246.     /*
  247.     **    Set up menus last, since the menu drawing can then use 
  248.     **    the palette we have for our window. 
  249.     **    Makes the Apple look better, in particular.
  250.     */
  251.     SetUpMenus();
  252.     
  253.     /*
  254.     **    Main Event Loop
  255.     */
  256.     do {
  257.         SystemTask();
  258.  
  259.         if (GetNextEvent(everyEvent, &myEvent)) {
  260.             switch (myEvent.what) {                /* case on event type */
  261.  
  262.                 case mouseDown:
  263.                     switch (FindWindow(myEvent.where, &whichWindow)) {
  264.  
  265.                         case inSysWindow:        /* desk accessory window: call Desk Manager to handle it */
  266.                             SystemClick(&myEvent, whichWindow);
  267.                             break;
  268.  
  269.                         case inMenuBar:            /* Menu bar: learn which command, then execute it. */
  270.                             DoCommand(MenuSelect(myEvent.where));
  271.                             break;
  272.  
  273.                         case inDrag:            /* title bar: call Window Manager to drag */
  274.                             DragWindow(whichWindow, myEvent.where, &dragRect);
  275.                             break;
  276.  
  277.                         case inContent:            /* body of application window: */
  278.                             if (whichWindow != FrontWindow())
  279.                                 SelectWindow(whichWindow); /* and make it active if not */
  280.                             break;
  281.                     }
  282.                     break;
  283.  
  284.                 case updateEvt:                    /* Update the eyes in window. */
  285.                     if ((WindowPtr) myEvent.message == myWindow) {
  286.                         BeginUpdate((WindowPtr) myEvent.message);
  287.                         DrawEyes();
  288.                         EndUpdate((WindowPtr) myEvent.message);
  289.                     }
  290.                     break;
  291.                             
  292.                 case keyDown:
  293.                 case autoKey:                    /* key pressed once or held down to repeat */
  294.                     if (myWindow == FrontWindow()) {
  295.                         theChar = (myEvent.message & charCodeMask); /* get the char */
  296.                         /* 
  297.                         **    If Command key down, do it as a Menu Command.
  298.                         */
  299.                         if (myEvent.modifiers & cmdKey)
  300.                             DoCommand(MenuKey(theChar));
  301.                     }
  302.                     break;
  303.  
  304.             }
  305.         }
  306.  
  307.         /*    
  308.         **    If we have menu item checked, go ahead and animate colors.
  309.         */
  310.         if (tubeCheck) ShiftyColors();
  311.         
  312.     } while (!doneFlag);
  313.  
  314.     /*
  315.     **    clean up after palette manager, 
  316.     **    so he can chuck the palette in use.
  317.     */
  318.     DisposeWindow (myWindow);
  319. }
  320.  
  321. /*
  322. **    This routine will update the window when required by update events.    It
  323. **    will draw two circular dudes that are indexed in colors through the colors
  324. **    we are using. 0 and 1 are skipped, since those are white and black in the
  325. **    palette.
  326. */
  327. void DrawEyes()
  328. {
  329.     Rect    tempRect;
  330.     int        i;
  331.     
  332.     SetRect(&tempRect, numColors, numColors, numColors, numColors);
  333.     for (i = 2; i <= totalColors; i++) {
  334.         PmForeColor(i);
  335.         FrameOval (&tempRect);
  336.         InsetRect (&tempRect, -1, -1);
  337.     }
  338.     
  339.     SetRect(&tempRect, numColors*3, numColors, numColors*3, numColors);
  340.     for (i = totalColors; i >= 2; i--) {
  341.         PmForeColor(i);
  342.         FrameOval (&tempRect);
  343.         InsetRect (&tempRect, -1, -1);
  344.     }
  345. }
  346.  
  347.  
  348. /*
  349. **    Read menu descriptions from resource file into memory 
  350. **    and store handles in myMenus array.
  351. **    Insert into MenuBar and draw.
  352. */
  353. void SetUpMenus()
  354. {
  355.     int i;
  356.  
  357.     myMenus[appleM] = GetMenu(appleID);         /* read Apple menu from resource file */
  358.     AppendResMenu(myMenus[appleM], 'DRVR');        /* add desk accessory names to Apple menu */
  359.     myMenus[fileM] = GetMenu(fileID);            /* read file menu from resource file */
  360.     myMenus[editM] = GetMenu(editID);            /* read edit menu from resource file */
  361.  
  362.     for (i = 0; i < menuCount; i++) 
  363.         InsertMenu(myMenus[i], 0);                 /* install menus in menu bar */
  364.     
  365.     DrawMenuBar();                                /* and draw menu bar */
  366. }
  367.  
  368.  
  369. /*
  370. **    Use the Palette currently attached to the main window to animate the colors 
  371. **    in the circular eye shapes.  This will rotate them around to give the flowing 
  372. **    tube effect. We make the palette into a color table so we can move entries 
  373. **    around.    We have to skip the first two entries since those are black and white. 
  374. **    (entries 0 and 1)
  375. */
  376. void ShiftyColors()
  377. {
  378.     
  379.     PaletteHandle    currPalette;
  380.     CTabHandle        destCTab;
  381.     ColorSpec        lastCSpec;
  382.     
  383.     SetPort (myWindow);
  384.     
  385.     currPalette = GetPalette(myWindow);
  386.     destCTab = (CTabHandle) NewHandle(sizeof(ColorTable)+(totalColors*sizeof(ColorSpec)));
  387.     if (destCTab == nil)  return;
  388.     Palette2CTab(currPalette, destCTab);
  389.     
  390.     /*
  391.     **    Move the colors around in the color table, skipping 0 and 1, and moving
  392.     **    all the elements down by one, and copying the element at 2 back to the 
  393.     **    end of the table. The effect is to rotate the colors in the table.
  394.     */
  395.     lastCSpec = (*destCTab)->ctTable[2];                        /* pull first one off. */
  396.     BlockMove (&(*destCTab)->ctTable[3], 
  397.                &(*destCTab)->ctTable[2], 
  398.                (numColors) * sizeof(ColorSpec) );                /* copy all one entry down. */
  399.     (*destCTab)->ctTable[totalColors-1] = lastCSpec;            /* put last color back on front. */
  400.         
  401.     AnimatePalette(myWindow, destCTab, 2, 2, numColors);
  402.     
  403.     DisposeHandle ((Handle) destCTab);
  404. }
  405.  
  406.  
  407. /*    
  408. **    Display the dialog box in response to the 'About TubeTest' menu item
  409. */
  410. void ShowAboutMeDialog()
  411. {
  412.     DialogPtr    theDialog;
  413.     short        itemHit;
  414.  
  415.     theDialog = GetNewDialog(aboutMeDLOG, nil, (WindowPtr) -1);
  416.     ModalDialog(nil, &itemHit);
  417.     DisposeDialog(theDialog);
  418. }
  419.  
  420.  
  421. /*
  422. **    Execute menu command specified by mResult,
  423. **    the result of MenuSelect
  424. */
  425. void DoCommand(long int mResult)
  426. {
  427.     short    theItem,                            /* menu item number from mResult low-order word */
  428.             theMenu;                            /* menu number from mResult high-order word */
  429.     Str255    name;                                /* desk accessory name */
  430.     int        temp;
  431.     Boolean    dummy;
  432.  
  433.     theItem = LoWord(mResult);                    /* call Toolbox Utility routines to */
  434.     theMenu = HiWord(mResult);                    /* set menu item number and menu */
  435.  
  436.     switch (theMenu) {                            /* switch on menu ID */
  437.  
  438.         case appleID:
  439.             if (theItem == aboutMeCommand)
  440.                 ShowAboutMeDialog();
  441.             else {
  442.                     GetMenuItemText(myMenus[appleM], theItem, name);
  443.                     temp = OpenDeskAcc(name);
  444.                     SetPort(myWindow);
  445.             }
  446.             break;
  447.  
  448.         case fileID:
  449.             if (theItem == quitItem)
  450.                 doneFlag = true;
  451.             else if (theItem = tubularItem) {
  452.                     tubeCheck = !tubeCheck;
  453.                     CheckItem(myMenus[fileM], tubularItem, tubeCheck);
  454.             }
  455.             break;
  456.  
  457.         case editID:
  458.             dummy = SystemEdit(theItem - 1);    /* Pass the command on to the Desk Manager. */
  459.             break;
  460.     }
  461.  
  462.     HiliteMenu(0);                                /* Unhighlight menu title */
  463.                                                 /* (highlighted by MenuSelect) */
  464. }
  465.